﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using GestorDocument.Model.IRepository;
using GestorDocument.Model;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Configuration;
using System.IO;
using System.Diagnostics;
using System.Net;
using GestorDocument.ViewModel.TreeViewDireccion;

namespace GestorDocument.ViewModel.AsuntoTurno
{
    public class TrancingAsuntoViewModel : ViewModelBase
    {
        public string MsjAtencion
        {
            get { return _MsjAtencion; }
            set
            {
                if (_MsjAtencion != value)
                {
                    _MsjAtencion = value;
                    OnPropertyChanged(MsjAtencionPropertyName);
                }
            }
        }
        private string _MsjAtencion;
        public const string MsjAtencionPropertyName = "MsjAtencion";

        public string ComentariosDG
        {
            get { return _ComentariosDG; }
            set
            {
                if (_ComentariosDG != value)
                {
                    _ComentariosDG = value;
                    OnPropertyChanged(ComentariosDGPropertyName);
                }
            }
        }
        private string _ComentariosDG;
        public const string ComentariosDGPropertyName = "ComentariosDG";

        public int RowHeight
        {
            get { return _RowHeight; }
            set
            {
                if (_RowHeight != value)
                {
                    _RowHeight = value;
                    OnPropertyChanged(RowHeightPropertyName);
                }
            }
        }
        private int _RowHeight;
        public const string RowHeightPropertyName = "RowHeight";

        public string TituloGrid
        {
            get { return _TituloGrid; }
            set
            {
                if (_TituloGrid != value)
                {
                    _TituloGrid = value;
                    OnPropertyChanged(TituloGridPropertyName);
                }
            }
        }
        private string _TituloGrid;
        public const string TituloGridPropertyName = "TituloGrid";

        public string BackgroundTitulo
        {
            get { return _BackgroundTitulo; }
            set
            {
                if (_BackgroundTitulo != value)
                {
                    _BackgroundTitulo = value;
                    OnPropertyChanged(BackgroundTituloPropertyName);
                }
            }
        }
        private string _BackgroundTitulo;
        public const string BackgroundTituloPropertyName = "BackgroundTitulo";

        public bool ISEmptyComentarioRechazo
        {
            get { return _ISEmptyComentarioRechazo; }
            set
            {
                _ISEmptyComentarioRechazo = value;
                OnPropertyChanged(ISEmptyComentarioRechazoPropertyName);
            }
        }
        private bool _ISEmptyComentarioRechazo;
        public const string ISEmptyComentarioRechazoPropertyName = "ISEmptyComentarioRechazo";

        #region PROPIEDADES DE RUTAS, DESCARGAS Y DOCUMEMENTOS LOCALES
        public string SuccessPath
        {
            get { return _SuccessPath; }
            set
            {
                if (_SuccessPath != value)
                {
                    _SuccessPath = value;
                    OnPropertyChanged(SuccessPathPropertyName);
                }
            }
        }
        private string _SuccessPath;
        public const string SuccessPathPropertyName = "SuccessPath";
        // ***************************** ***************************** *****************************
        public string SuccessPathServer
        {
            get { return _SuccessPathServer; }
            set
            {
                if (_SuccessPathServer != value)
                {
                    _SuccessPathServer = value;
                    OnPropertyChanged(SuccessPathServerPropertyName);
                }
            }
        }
        private string _SuccessPathServer;
        public const string SuccessPathServerPropertyName = "SuccessPathServer";
        // ***************************** ***************************** *****************************
        public Uri Descarga
        {
            get { return _Descarga; }
            set
            {
                if (_Descarga != value)
                {
                    _Descarga = value;
                    OnPropertyChanged(DescargaPropertyName);
                }
            }
        }
        private Uri _Descarga;
        public const string DescargaPropertyName = "Descarga";

        // ***************************** ***************************** *****************************
        public string[] FilesDocumetos
        {
            get { return _FilesDocumetos; }
            set
            {
                if (_FilesDocumetos != value)
                {
                    _FilesDocumetos = value;
                    OnPropertyChanged(FilesDocumetosPropertyName);
                }
            }
        }
        private string[] _FilesDocumetos;
        public const string FilesDocumetosPropertyName = "FilesDocumetos";

        #endregion

        #region Propiedades y Metodos Hilo
        public static bool IsRunning = false;
        System.Timers.Timer t;
        public string Message
        {
            get
            {
                return _message;
            }
            set
            {
                if (_message != value)
                {
                    _message = value;
                    OnPropertyChanged("Message");
                }
            }
        }
        string _message;
        public bool JobDone
        {
            get { return _jobDone; }
            set
            {
                if (value != _jobDone)
                {
                    this._jobDone = value;
                    OnPropertyChanged("JobDone");
                }
            }
        }
        bool _jobDone;

        #endregion

        #region ROL Y USUARIO
        public RolModel Rol
        {
            get { return _Rol; }
            set
            {
                if (_Rol != value)
                {
                    _Rol = value;
                    OnPropertyChanged(RolPropertyName);
                }
            }
        }
        private RolModel _Rol;
        public const string RolPropertyName = "Rol";

        public UsuarioModel Usuario
        {
            get { return _Usuario; }
            set
            {
                if (_Usuario != value)
                {
                    _Usuario = value;
                    OnPropertyChanged(UsuarioPropertyName);
                }
            }
        }
        private UsuarioModel _Usuario;
        public const string UsuarioPropertyName = "Usuario";

        #endregion

        #region TURNO

        public TurnoModel Turno
        {
            get { return _Turno; }
            set
            {
                if (_Turno != value)
                {
                    _Turno = value;
                    OnPropertyChanged(TurnoPropertyName);
                }
            }
        }
        private TurnoModel _Turno;
        public const string TurnoPropertyName = "Turno";

        #endregion

        #region EXPEDIENTE
        public ExpedienteModel Expediente
        {
            get { return _Expediente; }
            set
            {
                if (_Expediente != value)
                {
                    _Expediente = value;
                    OnPropertyChanged(ExpedientePropertyName);
                }
            }
        }
        private ExpedienteModel _Expediente;
        public const string ExpedientePropertyName = "Expediente";
        #endregion

        public IConfirmation _Confirmation;
        public IDownloadFile _Download;
        // ***************************** ***************************** *****************************
        // Repository.
        private ITurno _TurnoRepository;
        private IAsunto _AsuntoRepository;

        public bool IsStatusAsunto
        {
            get { return _IsStatusAsunto; }
            set
            {
                if (_IsStatusAsunto != value)
                {
                    _IsStatusAsunto = value;
                    OnPropertyChanged(IsStatusAsuntoPropertyName);
                }
            }
        }
        private bool _IsStatusAsunto;
        public const string IsStatusAsuntoPropertyName = "IsStatusAsunto";

        public bool Response
        {
            get { return _Response; }
            set
            {
                if (_Response != value)
                {
                    _Response = value;
                    OnPropertyChanged(ResponsePropertyName);
                }
            }
        }
        private bool _Response;
        public const string ResponsePropertyName = "Response";

        public AsuntoModel Asunto
        {
            get { return _Asunto; }
            set
            {
                if (_Asunto != value)
                {
                    _Asunto = value;
                    OnPropertyChanged(AsuntoPropertyName);
                }
            }
        }
        private AsuntoModel _Asunto;
        public const string AsuntoPropertyName = "Asunto";
        public AsuntoViewModel _ParentAsunto;
        
        public AsuntoModel SelectedAsuntoTurno
        {
            get { return _SelectedAsuntoTurno; }
            set
            {
                if (_SelectedAsuntoTurno != value)
                {
                    _SelectedAsuntoTurno = value;
                    OnPropertyChanged(SelectedAsuntoTurnoPropertyName);
                }
            }
        }
        private AsuntoModel _SelectedAsuntoTurno;
        public const string SelectedAsuntoTurnoPropertyName = "SelectedAsuntoTurno";

        public TurnoModel RechazarTurno
        {
            get { return _RechazarTurno; }
            set
            {
                if (_RechazarTurno != value)
                {
                    _RechazarTurno = value;
                    OnPropertyChanged(RechazarTurnoPropertyName);
                }
            }
        }
        private TurnoModel _RechazarTurno;
        public const string RechazarTurnoPropertyName = "RechazarTurno";


        // ***************************** ***************************** *****************************
        // Coleccion para extraer los datos para el treview

        public TreeViewSeguimientoViewModel TreeViewSeguimientoViewModel
        {
            get { return _TreeViewSeguimientoViewModel; }
            set
            {
                if (_TreeViewSeguimientoViewModel != value)
                {
                    _TreeViewSeguimientoViewModel = value;
                    OnPropertyChanged(TreeViewSeguimientoViewModelPropertyName);
                }
            }
        }
        private TreeViewSeguimientoViewModel _TreeViewSeguimientoViewModel;
        public const string TreeViewSeguimientoViewModelPropertyName = "TreeViewSeguimientoViewModel";

        public ObservableCollection<TurnoModel> Turnos
        {
            get { return _Turnos; }
            set
            {
                if (_Turnos != value)
                {
                    _Turnos = value;
                    OnPropertyChanged(TurnosPropertyName);
                }
            }
        }
        private ObservableCollection<TurnoModel> _Turnos;
        public const string TurnosPropertyName = "Turnos";

        // ***************************** ***************************** *****************************
        // Coleccion para extraer los datos para el lisbox
        public ObservableCollection<TurnoModel> SeguimientoTurnos
        {
            get { return _SeguimientoTurnos; }
            set
            {
                if (_SeguimientoTurnos != value)
                {
                    _SeguimientoTurnos = value;
                    OnPropertyChanged(SeguimientoTurnosPropertyName);
                }
            }
        }
        private ObservableCollection<TurnoModel> _SeguimientoTurnos;
        public const string SeguimientoTurnosPropertyName = "SeguimientoTurnos";

        public TurnoModel SelectedSeguimientoTurnos
        {
            get { return _SelectedSeguimientoTurnos; }
            set
            {
                if (_SelectedSeguimientoTurnos != value)
                {
                    _SelectedSeguimientoTurnos = value;
                    OnPropertyChanged(SelectedSeguimientoTurnosPropertyName);
                }
            }
        }
        private TurnoModel _SelectedSeguimientoTurnos;
        public const string SelectedSeguimientoTurnosPropertyName = "SelectedSeguimientoTurnos";

        // ***************************** ***************************** *****************************
        // Coleccion para extraer los datos para el listView Expediente
        private IExpediente _ExpedienteRepository;
        public ObservableCollection<ExpedienteModel> ExpedienteDocumento
        {
            get { return _ExpedienteDocumento; }
            set
            {
                if (_ExpedienteDocumento != value)
                {
                    _ExpedienteDocumento = value;
                    OnPropertyChanged(ExpedienteDocumentoPropertyName);
                }
            }
        }
        private ObservableCollection<ExpedienteModel> _ExpedienteDocumento;
        public const string ExpedienteDocumentoPropertyName = "ExpedienteDocumento";

        public ExpedienteModel SelectedExpedienteDocumento
        {
            get { return _SelectedExpedienteDocumento; }
            set
            {
                if (_SelectedExpedienteDocumento != value)
                {
                    _SelectedExpedienteDocumento = value;
                    OnPropertyChanged(SelectedExpedienteDocumentoPropertyName);
                }
            }
        }
        private ExpedienteModel _SelectedExpedienteDocumento;
        public const string SelectedExpedienteDocumentoPropertyName = "SelectedExpedienteDocumento";
        // SIGNATARIO EXTERNO. 
        public ObservableCollection<SignatarioExternoModel> SignatarioExterno
        {
            get { return _SignatarioExterno; }
            set
            {
                if (_SignatarioExterno != value)
                {
                    _SignatarioExterno = value;
                    OnPropertyChanged(SignatarioExternoPropertyName);
                }
            }
        }
        private ObservableCollection<SignatarioExternoModel> _SignatarioExterno;
        public const string SignatarioExternoPropertyName = "SignatarioExterno";

        #region BOTON  CERRAR TURNO, VALIDAR TURNO , RECHAZAR TURNO y COMENTARIO
        // ***************************** ***************************** *****************************
        // boton cerrar turno.
        public RelayCommand CerrarTurnoCommand
        {
            get
            {
                if (_CerrarTurnoCommand == null)
                {
                    _CerrarTurnoCommand = new RelayCommand(p => this.AttemptCerrarTurno(), p => this.CanCerrar());
                }
                return _CerrarTurnoCommand;
            }
        }
        private RelayCommand _CerrarTurnoCommand;
        public bool CanCerrar()
        {
            return true;
        }
        public void AttemptCerrarTurno()
        {
            if (this.GetValidarCerrarTurno())
            {
                this._Confirmation.Msg = "! Esta seguro de finalizar este asunto ¡";
                this._Confirmation.Show();

                if (this._Confirmation.Response)
                {
                    this.GetCerrarTurno();
                    //REFERESCAR EL GRID
                    this._ParentAsunto._PantallaInicioViewModel.LoadInfoGrid();
                }
            }
        }

        // boton VALIDAR cerrar turno.
        public RelayCommand ValidarCerrarTurnoCommand
        {
            get
            {
                if (_ValidarCerrarTurnoCommand == null)
                {
                    _ValidarCerrarTurnoCommand = new RelayCommand(p => this.AttemptValidarCerrarTurno(), p => this.CanValidarCerrar());
                }
                return _ValidarCerrarTurnoCommand;
            }
        }
        private RelayCommand _ValidarCerrarTurnoCommand;
        public bool CanValidarCerrar()
        {
            bool _CanCerrar = this.GetDesactiveButton(); 
            //solo valida
            return _CanCerrar;
        }
        public void AttemptValidarCerrarTurno()
        {
            //solo valida
        }

        //Boton para rechazar turno
        public RelayCommand RechazarTurnoCommand
        {
            get
            {
                if (_RechazarTurnoCommand == null)
                {
                    _RechazarTurnoCommand = new RelayCommand(p => this.AttemptRechazarTurno(), p => this.RechazarTurnoView());
                }
                return _RechazarTurnoCommand;
            }
        }
        private RelayCommand _RechazarTurnoCommand;
        public bool RechazarTurnoView()
        {
            bool _CanRechazar = false;
            //solo rechaza
            return _CanRechazar;
        }
        public void AttemptRechazarTurno()
        {
            this.GetRechazarAsunto();
        }

        //Boton para  validar rechazar turno
        public RelayCommand ValidarRechazarTurnoCommand
        {
            get
            {
                if (_ValidarRechazarTurnoCommand == null)
                {
                    _ValidarRechazarTurnoCommand = new RelayCommand(p => this.AttemptValidarRechazarTurno(), p => this.CanRechazarTurno());
                }
                return _ValidarRechazarTurnoCommand;
            }
        }
        private RelayCommand _ValidarRechazarTurnoCommand;
        public bool CanRechazarTurno()
        {
            bool _CanRechazar =false;

            if (!string.IsNullOrWhiteSpace(this.RechazarTurno.RechazoComentario))
            {
                _CanRechazar = true;
                this.ISEmptyComentarioRechazo = false;
            }    
            else
                this.ISEmptyComentarioRechazo = true;
            //solo valida
            return _CanRechazar;
        }
        public void AttemptValidarRechazarTurno()
        {
            //solo valida
        }

        //Boton para GUARDAR COMENTARIO
        public RelayCommand SaveComentarioCommand
        {
            get
            {
                if (_SaveComentarioCommand == null)
                {
                    _SaveComentarioCommand = new RelayCommand(p => this.AttemptSaveComentario(), p => this.SaveComentario());
                }
                return _SaveComentarioCommand;
            }
        }
        private RelayCommand _SaveComentarioCommand;
        public bool SaveComentario()
        {
            bool _CanComentario = true;
            //solo guarda comentraio
            return _CanComentario;
        }
        public void AttemptSaveComentario()
        {
            this.GetSaveComentarioDG();
        }

        //Boton para validar comentario
        public RelayCommand ValidarComentarioCommand
        {
            get
            {
                if (_ValidarComentarioCommand == null)
                {
                    _ValidarComentarioCommand = new RelayCommand(p => this.AttemptComentario(), p => this.ValidarComentario());
                }
                return _ValidarComentarioCommand;
            }
        }
        private RelayCommand _ValidarComentarioCommand;
        public bool ValidarComentario()
        {
            bool _CanComentario = this.GetDesactiveButton();
            //solo guarda comentraio
            return _CanComentario;
        }
        public void AttemptComentario()
        {
            //solo valida
        }

        #endregion

        public TurnoModel ParentTrancing
        {
            get { return _ParentTrancing; }
            set
            {
                if (_ParentTrancing != value)
                {
                    _ParentTrancing = value;
                }
            }
        }
        private TurnoModel _ParentTrancing;

        // Repository. SIGNATARIOS
        private ISignatario _SignatarioRepository;
        // Repository. DESTINATARIOS
        private IDestinatario _DestinatarioRepository;
        // SIGNATARIO EXTERNO. 
        private ISignatarioExterno _SignatarioExternoRepository;

        #region IMPRIMIR CARATULA
        // IMPRIMIR
        public RelayCommand ImprimirCommand
        {
            get
            {
                if (_ImprimirCommand == null)
                {
                    _ImprimirCommand = new RelayCommand(p => this.AttemptImprimir(), p => this.CanImprimir());
                }

                return _ImprimirCommand;
            }

        }
        private RelayCommand _ImprimirCommand;

        public bool CanImprimir()
        {
            //por si se usa
            return true;
        }
        public void AttemptImprimir()
        {
            //solo valida
        }

        public AsuntoModel ImprimirAsunto
        {
            get { return _ImprimirAsunto; }
            set
            {
                if (_ImprimirAsunto != value)
                {
                    _ImprimirAsunto = value;
                    OnPropertyChanged(ImprimirAsuntoPropertyName);
                }
            }
        }
        private AsuntoModel _ImprimirAsunto;
        public const string ImprimirAsuntoPropertyName = "ImprimirAsunto";

        public AsuntoModel ReadAsunto
        {
            get { return _ReadAsunto; }
            set
            {
                if (_ReadAsunto != value)
                {
                    _ReadAsunto = value;
                    OnPropertyChanged(ReadAsuntoPropertyName);
                }
            }
        }
        private AsuntoModel _ReadAsunto;
        public const string ReadAsuntoPropertyName = "ReadAsunto";
        #endregion 

        #region SINCRONIZACION DE DOCUMENTOS
        // ***************************** ***************************** *****************************
        // Repository. SYNC_DOC
        private ISyncDocs _SyncDocsRepository;

        // SYNC_DOC. 
        public ObservableCollection<SyncDocsModel> SyncDocs
        {
            get { return _SyncDocs; }
            set
            {
                if (_SyncDocs != value)
                {
                    _SyncDocs = value;
                    OnPropertyChanged(SyncDocsPropertyName);
                }
            }
        }
        private ObservableCollection<SyncDocsModel> _SyncDocs;
        public const string SyncDocsPropertyName = "SyncDocs";

        #endregion

        #region DOCUMENTOS
        // Repository. DOCMENTOS
        private IDocumentos _DocumentosRepository;
        // GRID DOCMENTOS
        public ObservableCollection<DocumentosModel> Documentos
        {
            get { return _Documentos; }
            set
            {
                if (_Documentos != value)
                {
                    _Documentos = value;
                    OnPropertyChanged(DocumentosPropertyName);
                }
            }
        }
        private ObservableCollection<DocumentosModel> _Documentos;
        public const string DocumentosPropertyName = "Documentos";

        #endregion

        #region NUEVOS DOCUMENTOS
        // NUEVOS DOCMENTOS
        public ObservableCollection<DocumentosModel> NewDocumentos
        {
            get { return _NewDocumentos; }
            set
            {
                if (_NewDocumentos != value)
                {
                    _NewDocumentos = value;
                    OnPropertyChanged(NewDocumentosPropertyName);
                }
            }
        }
        private ObservableCollection<DocumentosModel> _NewDocumentos;
        public const string NewDocumentosPropertyName = "NewDocumentos";
        #endregion

        #region BORRADO  DOCUMENTOS
        // BORRADO DOCMENTOS
        public ObservableCollection<DocumentosModel> DeleteDocumentos
        {
            get { return _DeleteDocumentos; }
            set
            {
                if (_DeleteDocumentos != value)
                {
                    _DeleteDocumentos = value;
                    OnPropertyChanged(DeleteDocumentosPropertyName);
                }
            }
        }
        private ObservableCollection<DocumentosModel> _DeleteDocumentos;
        public const string DeleteDocumentosPropertyName = "DeleteDocumentos";

        #endregion

        #region BOTON PARA ELIMINAR DOCUMENTOS
        // ***************************** ***************************** *****************************
        // ELiminar Documentos.
        public RelayCommand DeleteDocumentosCommand
        {
            get
            {
                if (_DeleteDocumentosCommand == null)
                {
                    _DeleteDocumentosCommand = new RelayCommand(p => this.AttemptDeleteDocumentos(), p => this.CanDeleteDocumentos());
                }

                return _DeleteDocumentosCommand;
            }

        }
        private RelayCommand _DeleteDocumentosCommand;
        public bool CanDeleteDocumentos()
        {
            bool _CanDelete = false;

            foreach (DocumentosModel p in this.Documentos)
            {
                if (p.IsCheckedDelete)
                {
                    _CanDelete = true;
                    break;

                }
            }
            return _CanDelete;
        }
        public void AttemptDeleteDocumentos()
        {
            //TODO : Delete to database
            try
            {
                var query = (from o in this.Documentos
                             where o.IsCheckedDelete == true
                             select o).ToList();
                if (query.Count != 0)
                {
                    (from o in query
                     where o.IsCheckedDelete == true
                     select o).ToList().ForEach(o => this.DeleteDocumentos.Add(o));
                }

                (from o in this.Documentos
                 where o.IsCheckedDelete == true
                 select o).ToList().ForEach(o => this.Documentos.Remove(o));
            }
            catch (Exception)
            {
            }
        }

        #endregion

        #region BOTON PARA GUARDAR DOCUMENTOS y VALIDAR DOCUMENTOS
        // ***************************** ***************************** *****************************
        // Guardar Documentos.
        public RelayCommand SaveDocumentosCommand
        {
            get
            {
                if (_SaveDocumentosCommand == null)
                {
                    _SaveDocumentosCommand = new RelayCommand(p => this.AttemptSaveDocumentos(), p => this.CanSaveDocumentos());
                }

                return _SaveDocumentosCommand;
            }

        }
        private RelayCommand _SaveDocumentosCommand;
        public bool CanSaveDocumentos()
        {
            bool _CanSave = true;

            //Solo Guarda
            return _CanSave;
        }
        public void AttemptSaveDocumentos()
        {
            this.GetSaveDocs();

            this.GetRefreshDocs();
        }

        //Boton para validar comentario
        public RelayCommand ValidarDocumentosCommand
        {
            get
            {
                if (_ValidarDocumentosCommand == null)
                {
                    _ValidarDocumentosCommand = new RelayCommand(p => this.AttemptDocumentos(), p => this.ValidarDocumentos());
                }
                return _ValidarDocumentosCommand;
            }
        }
        private RelayCommand _ValidarDocumentosCommand;
        public bool ValidarDocumentos()
        {
            bool _CanDocumento = this.GetDesactiveButton();
            return _CanDocumento;
        }
        public void AttemptDocumentos()
        {
            //solo valida
        }
        #endregion

        #region CONTRUCTOR
        public TrancingAsuntoViewModel(AsuntoViewModel asuntoViewModel, AsuntoModel selectedAsuntoTurno, IConfirmation confirmation, IDownloadFile download)
        {
            this._Confirmation = confirmation;
            this._Download = download;
            this._ParentAsunto = asuntoViewModel;
            this._SelectedAsuntoTurno = selectedAsuntoTurno;
            this._TurnoRepository = new GestorDocument.DAL.Repository.TurnoRepository();
            this._AsuntoRepository = new GestorDocument.DAL.Repository.AsuntoRepository();
            this._ExpedienteRepository = new GestorDocument.DAL.Repository.ExpedienteRepository();
            this._Turnos = new ObservableCollection<TurnoModel>();
            this._SeguimientoTurnos = new ObservableCollection<TurnoModel>();
            this._SignatarioRepository = new GestorDocument.DAL.Repository.SignatarioRepository();
            this._DestinatarioRepository = new GestorDocument.DAL.Repository.DestinatarioRepository();
            this._DocumentosRepository = new GestorDocument.DAL.Repository.DocumentosRepository();
            this._SyncDocsRepository = new GestorDocument.DAL.Repository.SyncDocsRepository();
            this._SignatarioExternoRepository = new GestorDocument.DAL.Repository.SignatarioExternoRepository();
            this.SignatarioExterno = new ObservableCollection<SignatarioExternoModel>();
            this._SuccessPathServer = ConfigurationManager.AppSettings["ServerDocsFolder"].ToString();

            if (this.SelectedAsuntoTurno.IdStatusAsunto != 20130611180608439)
                this._IsStatusAsunto = true;
                

            this.GetRol();

            this.GetUsuario();
            
            this.LoadInfoGrid();

            this.GetAsunto();

            this.GetTurno();

            this.GetExpediente();

            this.GetAtendidoTurnado();
        }
        #endregion

        #region METODOS

        public void LoadInfoGrid()
        {
            this.Documentos = this._DocumentosRepository.GetDocumentos(this._SelectedAsuntoTurno.Turno.IdTurno) as ObservableCollection<DocumentosModel>;
            this.DeleteDocumentos = new ObservableCollection<DocumentosModel>();
            this.NewDocumentos = new ObservableCollection<DocumentosModel>();
            this.SyncDocs = new ObservableCollection<SyncDocsModel>();

            //para obtener los datos del seguimiento
            ObservableCollection<TurnoModel> seguimiento = this._TurnoRepository.GetTurnosTrancing(this._SelectedAsuntoTurno.IdAsunto) as ObservableCollection<TurnoModel>;

            seguimiento.ToList().ForEach(t =>
                {
                    if (t.IdTurnoAnt == null)
                    {
                        t.CanCheck = false;
                        t.CanButton = false;
                    }
                    else
                        t.CanButton = true;

                    if (t.IsAtendido)
                        t.FechaAtendidoTurnado = "Fecha de Atención";

                    if (t.IsTurnado)
                        t.FechaAtendidoTurnado = "Fecha de Envio";

                    if (!string.IsNullOrWhiteSpace(t.Destinatarios))
                        t.VisibilityDireccion = true;

                    if (!string.IsNullOrWhiteSpace(t.Comentario))
                        t.VisibilityProperty = true;

                    if (!this._IsStatusAsunto)
                        t.CanButton = false;
                });

            this.SeguimientoTurnos = seguimiento;

            this.ComentariosDG = this.SeguimientoTurnos.First().Comentario;

            //para obtener los datos del expediente
            this.GetRefreshDocs();

            //ruta de los documentos
            this.GetSplitDirectory();

            //para obtener el arbol
            this.TreeViewSeguimientoViewModel = new TreeViewSeguimientoViewModel(this._SelectedAsuntoTurno, this.Rol, null);

            this.TreeViewSeguimientoViewModel.Children.ToList()
                .ForEach(p=>
                {
                    if (!p.IsExpanded)
                        p.IsExpanded = true;
                });
        }

        public bool GetValidarCerrarTurno()
        {
            bool respose = true;
            this.Response = true;
            int cont = _TurnoRepository.GetTurnoCloseAsunto(this._SelectedAsuntoTurno.IdAsunto);
            if (cont !=0)
            {
               this._Confirmation.Msg = " ! No se puede finalizar Asunto ¡";
               this._Confirmation.ShowOk();
               respose = false;
               this.Response = false;
            }

            return respose;
        }

        public void GetCerrarTurno()
        {
            this._Asunto = new AsuntoModel() 
            {
                IdAsunto = this.SelectedAsuntoTurno.IdAsunto
                ,
                IdStatusAsunto = 20130611180608439
                ,
                FechaAtendido = DateTime.Now
            };
            this._AsuntoRepository.UpdateCloseAsunto(this.Asunto);
        }

        public void GetSplitDirectory()
        {
            string nameFolder = ConfigurationManager.AppSettings["LocalDocsApp"].ToString();

            string appDirectory = System.IO.Directory.GetCurrentDirectory();
            string[] directory = System.IO.Directory.GetFileSystemEntries(appDirectory);

            foreach (string ruta in directory)
            {
                string[] _DocumentoPath = ruta.Split('\\');
                if (nameFolder == _DocumentoPath.Last())
                {
                    this.SuccessPath = ruta + "\\";
                    break;
                }
            }
        }

        public void GetImprimirAsunto()
        {
            this.ImprimirAsunto = new AsuntoModel();
            this.ImprimirAsunto = this.SelectedAsuntoTurno;
            this.ImprimirAsunto.Turno = (from o in this.SeguimientoTurnos
                                         select o).First();
        }

        public void GetReadAsunto()
        {
            this.ReadAsunto = new AsuntoModel();
            this.ReadAsunto = this.SelectedAsuntoTurno;
            this.ReadAsunto.Turno = (from o in this.SeguimientoTurnos
                                         select o).First();

            this.SignatarioExterno = this._SignatarioExternoRepository.GetSignatariosExterno(this.SelectedAsuntoTurno.IdAsunto) as ObservableCollection<SignatarioExternoModel>;

            this.ReadAsunto.SignatarioExterno = this.SignatarioExterno;
            
        }

        public void GetAtendidoTurnado()
        {
            long idAtendido = 20130611180608439;

            //ATENDIDOS
            if (this.SelectedAsuntoTurno.IdStatusAsunto == idAtendido)
            {
                this.TituloGrid = "ASUNTO FINALIZADO...";
                this.BackgroundTitulo = "#088A08";
                this.RowHeight = 30;
            }
                
                

            //asuntos vencidos
            if (this.SelectedAsuntoTurno.FechaAtendido != null)
            {
                DateTime fechaVencimiento = DateTime.Parse(string.Format("{0:dd/MM/yyyy}", this.SelectedAsuntoTurno.FechaVencimiento));
                DateTime fechaAtendido = DateTime.Parse(string.Format("{0:dd/MM/yyyy}", this.SelectedAsuntoTurno.FechaAtendido));

                if (fechaVencimiento < fechaAtendido && this.SelectedAsuntoTurno.IdStatusAsunto == idAtendido)
                {
                    this.TituloGrid = "ASUNTO VENCIDO";
                    this.BackgroundTitulo = "#FE2E2E";
                    this.RowHeight = 30;
                } 
            }
            else
            {
                DateTime fechaVencimiento = DateTime.Parse(string.Format("{0:dd/MM/yyyy}", this.SelectedAsuntoTurno.FechaVencimiento));
                DateTime fechaSistema = DateTime.Parse(string.Format("{0:dd/MM/yyyy}", DateTime.Now));
                //asuntos vencidos
                if (fechaVencimiento < fechaSistema)
                {
                    this.TituloGrid = "ASUNTO VENCIDO";
                    this.BackgroundTitulo = "#FE2E2E";
                    this.RowHeight = 30;
                }
            }

            //asuntos por vencer
            if (this.SelectedAsuntoTurno.FechaAtendido == null)
            {
                DateTime fechaVencimiento = DateTime.Parse(string.Format("{0:dd/MM/yyyy}", this.SelectedAsuntoTurno.FechaVencimiento));
                DateTime fechaRangoInicio = DateTime.Parse(string.Format("{0:dd/MM/yyyy}", DateTime.Now));

                //detro de la fecha limite
                if (fechaVencimiento >= fechaRangoInicio)
                {
                    this.TituloGrid = "ASUNTO POR VECER";
                    this.BackgroundTitulo = "#FF8000";
                    this.RowHeight = 30;
                } 
            }
            //if (this.SelectedAsuntoTurno.IdStatusAsunto == 20130611180608439)
            //{
            //    this.MsjAtencion = "ASUNTO FINALIZADO...";
                
            //    this.RowHeight = 30;
            //}
            //else
            //    this.RowHeight = 0;
        }

        private void GetRol()
        {
            this.Rol = this._ParentAsunto._PantallaInicioViewModel._MainWindowViewModel.Usuario.Rol;
        }

        private void GetUsuario()
        {
            this.Usuario = this._ParentAsunto._PantallaInicioViewModel._MainWindowViewModel.Usuario;
        }

        public void GetAsunto()
        {
            this._Asunto = new AsuntoModel()
            {
                IdAsunto = this._SelectedAsuntoTurno.IdAsunto
                ,
                FechaCreacion = this._SelectedAsuntoTurno.FechaCreacion
                ,
                FechaRecibido = this._SelectedAsuntoTurno.FechaRecibido
                ,
                FechaDocumento = this._SelectedAsuntoTurno.FechaDocumento
                ,
                ReferenciaDocumento = this._SelectedAsuntoTurno.ReferenciaDocumento
                ,
                Titulo = this._SelectedAsuntoTurno.Titulo
                ,
                Descripcion = this._SelectedAsuntoTurno.Descripcion
                ,
                Alcance = this._SelectedAsuntoTurno.Alcance
                ,
                Ubicacion = (this._SelectedAsuntoTurno.Ubicacion != null) ? new UbicacionModel
                {
                    IdUbicacion = (long)this._SelectedAsuntoTurno.IdUbicacion
                    ,
                    UbicacionName = this._SelectedAsuntoTurno.Ubicacion.UbicacionName
                } : null
                ,
                Instruccion = (this._SelectedAsuntoTurno.Instruccion != null) ? new InstruccionModel
                {
                    IdInstruccion = (long)this._SelectedAsuntoTurno.IdInstruccion
                    ,
                    InstruccionName = this._SelectedAsuntoTurno.Instruccion.InstruccionName
                } : null
                ,
                Prioridad = (this._SelectedAsuntoTurno.Prioridad != null) ? new PrioridadModel
                {
                    IdPrioridad = (long)this._SelectedAsuntoTurno.IdPrioridad
                    ,
                    PrioridadName = this._SelectedAsuntoTurno.Prioridad.PrioridadName
                } : null
                ,
                StatusAsunto = new StatusAsuntoModel
                {
                    IdStatusAsunto = (long)this._SelectedAsuntoTurno.IdStatusAsunto
                    ,
                    StatusName = this._SelectedAsuntoTurno.StatusAsunto.StatusName
                }
                ,
                FechaVencimiento = this._SelectedAsuntoTurno.FechaVencimiento
                ,
                Folio = this._SelectedAsuntoTurno.Folio
            };
        }

        public void GetTurno()
        {
            this.Turno = new TurnoModel()
            {
                IdTurnoAnt = this._SelectedAsuntoTurno.Turno.IdTurnoAnt
                ,
                IdTurno = this._SelectedAsuntoTurno.Turno.IdTurno
                ,
                FechaCreacion = this._SelectedAsuntoTurno.Turno.FechaCreacion
                ,
                FechaEnvio = this._SelectedAsuntoTurno.Turno.FechaEnvio
                ,
                IsActive = this._SelectedAsuntoTurno.Turno.IsActive
                ,
                IdAsunto = this._SelectedAsuntoTurno.Turno.IdAsunto
                ,
                IdStatusTurno = this._SelectedAsuntoTurno.Turno.IdStatusTurno
                ,
                IdRol = this._SelectedAsuntoTurno.Turno.IdRol
                ,
                IdUsuario = this._SelectedAsuntoTurno.Turno.IdUsuario
                ,
                IsAtendido = this._SelectedAsuntoTurno.Turno.IsAtendido
                ,
                IsTurnado = this._SelectedAsuntoTurno.Turno.IsTurnado
                ,
                IsBorrador = this._SelectedAsuntoTurno.Turno.IsBorrador
                ,
                Respuesta = (!string.IsNullOrWhiteSpace(this.SelectedAsuntoTurno.Turno.Comentario)) ? this.SelectedAsuntoTurno.Turno.Respuesta + "\r" : this.SelectedAsuntoTurno.Turno.Respuesta
                ,
                RechazoComentario = this.SelectedAsuntoTurno.Turno.RechazoComentario
            };
        }

        public void GetExpediente()
        {
            this.Expediente = new ExpedienteModel()
            {
                IdExpediente = this._SelectedAsuntoTurno.Expediente.IdExpediente
                ,
                IdAsunto = this._SelectedAsuntoTurno.Expediente.IdAsunto
                ,
                Asunto = this.Asunto
                ,
                IsActive = this._SelectedAsuntoTurno.Expediente.IsActive
            };
        }

        public void GetDocumentos()
        {
            foreach (DocumentosModel doc in this.Documentos)
            {
                if (doc.IdExpediente == 0 && doc.IdTurno == null)
                {
                    doc.IdExpediente = this.Expediente.IdExpediente;
                    doc.IdTurno = this.Turno.IdTurno;
                    doc.IdTipoDocumento = doc.TipoDocumento.IdTipoDocumento;

                    this.NewDocumentos.Add(doc);
                }
            }
        }

        public void GetDeleteDocumentos()
        {
            foreach (DocumentosModel doc in this.DeleteDocumentos)
                File.Delete(this.SuccessPath + doc.IdDocumento + "." + doc.Extencion);
        }

        public void GetRechazarAsunto()
        {
            this._Confirmation.Msg = "! Esta seguro de rechazar este turno ¡";

            this._Confirmation.Show();

            if (this._Confirmation.Response)
            {
                // rechaza el turno y lo modifica
                this.RechazarTurno.IsAtendido = false;
                this.RechazarTurno.IsTurnado = false;
                this.RechazarTurno.IsBorrador = true;
                this.RechazarTurno.FechaEnvio = null;
                this.RechazarTurno.IdStatusTurno = 1;
                _TurnoRepository.UpdateTurno(this.RechazarTurno);
            }
        }

        public void GetSaveComentarioDG()
        {
            this.SeguimientoTurnos.First().Comentario = this.ComentariosDG;
            _TurnoRepository.UpdateTurno(this.SeguimientoTurnos.First());
            
        }

        public void GetSaveDocs()
        {
            //insertamos y borramos en la tabla de relacion  GET_DOCUMENTOS
            this.GetDocumentos();

            if (this.DeleteDocumentos.Count != 0)
            {
                this._DocumentosRepository.DeleteDocumentos(this.DeleteDocumentos);
                this.GetDeleteDocumentos();
            }

            if (this.NewDocumentos.Count != 0)
            {
                this._DocumentosRepository.InsertDocumentos(this.NewDocumentos);
                //llenado de la tabla SYNC_DOC para la sincronizacion de  documento
                this.GetSyncDocs();
                this._SyncDocsRepository.InsertSyncDocs(this._SyncDocs);
            }
        }

        public void GetSyncDocs()
        {
            foreach (DocumentosModel doc in this.NewDocumentos)
            {
                SyncDocsModel syncDoc = new SyncDocsModel()
                {
                    IdDocumento = doc.IdDocumento
                    ,
                    StatusDoc = "PENDIENTE"
                    ,
                    BanderaStatus = false
                    ,
                    Extencion = doc.Extencion
                };

                this.SyncDocs.Add(syncDoc);
            }
        }

        public void GetRefreshDocs()
        {
            this.ExpedienteDocumento = new ObservableCollection<ExpedienteModel>();
            this.ExpedienteDocumento = this._ExpedienteRepository.GetExpediente(this._SelectedAsuntoTurno.Expediente.IdExpediente) as ObservableCollection<ExpedienteModel>;
        }

        public bool GetDesactiveButton()
        {
            return this._IsStatusAsunto;
        }
        #endregion

        #region METODOS DEL HILO

        public void SetOpenDoc()
        {
            this.Message = "Espere Abriendo documento ..."; 
            this._jobDone = false;
            t = new System.Timers.Timer(1000);
            t.Enabled = false;

            t.Elapsed += new System.Timers.ElapsedEventHandler(DlgDoc);

        }

        private string SearchDocumento(long idDocumento)
        {
            string resPathDoc = null;
            try
            {
                string pathDoc = this.SuccessPath;
                pathDoc = pathDoc + this.SelectedExpedienteDocumento.Documento.IdDocumento + "." + this.SelectedExpedienteDocumento.Documento.Extencion;

                if (File.Exists(pathDoc))
                    resPathDoc = pathDoc;
            }
            catch (Exception)
            {
                ;
            }
            return resPathDoc;
        }

        public void CierraDlg()
        {
            TrancingAsuntoViewModel.IsRunning = false;
            this.JobDone = true;
        }

        public void DlgDoc(Object sender, System.Timers.ElapsedEventArgs args)
        {

            this.t.Enabled = false;
            ((System.Timers.Timer)sender).Stop();
            //ABRE EL DOCUMENTO
            this.OpenDoc();
            
        }

        public void start()
        {
            this.JobDone = false;
            TrancingAsuntoViewModel.IsRunning = true;
            t.Enabled = true;
            t.Start();
        }

        public void OpenDoc()
        {
            if (this.SelectedExpedienteDocumento !=null)
            {
              string ruta =  this.SearchDocumento(this.SelectedExpedienteDocumento.Documento.IdDocumento);

              if (!String.IsNullOrEmpty(ruta))
              {
                  Process process = new Process();
                  process.StartInfo.FileName = ruta;
                  process.StartInfo.UseShellExecute = true;
                  process.Start();
                  this.CierraDlg();
              }
              else
              {
                  this.CierraDlg();
                  this.DownloadFile();
              }
              
            }
        }

        public void DownloadFile()
        {
            bool reponse = false;

            _Confirmation.Msg = "Archivo no se encuentra en la PC\n ¿ Desea Descargarlo ?";
            _Confirmation.Show();

            reponse = _Confirmation.Response;
            if (reponse)
            {
                _Download.Show(this);
            }
            
        }

        public void DescargandoDocumentoServer()
        {
            try
            {
                string pathDoc = this.SuccessPathServer;
                pathDoc = pathDoc + this.SelectedExpedienteDocumento.Documento.IdDocumento + "." + this.SelectedExpedienteDocumento.Documento.Extencion;

                if (File.Exists(pathDoc))
                {
                    this.Descarga = new Uri(this.SuccessPathServer + this.SelectedExpedienteDocumento.Documento.IdDocumento + "." + this.SelectedExpedienteDocumento.Documento.Extencion);
                }
                else
                {
                    _Download.Msg = "NO HAY CONEXION CON EL SERVIDOR";
                    _Download.ShowOk();
                    this.CierraDlg();
                }
            }
            catch (Exception)
            {
                
                ;
            }
        }
        #endregion
    }
}
